#include "routedb.h"

RouteDB::RouteDB()
{
    dbIsOPen = false;
}


RouteDB::~RouteDB()
{

}

void RouteDB::setResourcePath(const QString& resource)
{
    DB.setResourcePath(resource);
}

/*******************************************
  功能：打开数据库
  ******************************************/
bool RouteDB::openDB(const QString &DBPath)
{
    dbIsOPen = DB.openDB(DBPath);
    return dbIsOPen;
}


/*******************************************
  功能：关闭数据库
  ******************************************/
bool RouteDB::closeDB()
{
    if (dbIsOPen)
    {
        if(DB.closeDB())
        {
            dbIsOPen = true;
            return true;
        } else {
            return false;
        }
    } else {
        return true;
    }
}

/*******************************************
  功能：查询数据是否打开
  ******************************************/
bool RouteDB::isOpen()
{
    return dbIsOPen;
}

/*******************************************
  功能：得到播放包列表
  参数：routeMsgStruct，线路信息结构体,提供线路的基本信息
  返回值：得到播放包列表
  ******************************************/
PLAYPKGERR RouteDB::getCustomPlayPkgList(QList<RoutePkgList>& routePkgList, const RouteMsgStruct& routeMsgStruct) const
{

//    qDebug() << "routeMsgStruct===>" << routeMsgStruct.currentStationCode << routeMsgStruct.positionIncar << routeMsgStruct.routeCode << routeMsgStruct.trainStatusID;
    QList<PkgRelatStruct> PkgRelatStructList;
    QList<RoutePkgStruct> routePkgStructList;

    MainRelatIDStruct mainRelatIDStruct;
    RouteMsgStruct RMStruct = routeMsgStruct;
    PLAYPKGERR playPkgErr = NOERR;

    //先完善 线路信息ID结构体
    mainRelatIDStruct.trainDirectionID = DB.getTrainDirectID(RMStruct.routeCode);

    if (mainRelatIDStruct.trainDirectionID == -1)
    {
        playPkgErr = DIRECTEIDERR;
        return playPkgErr;
    }

    mainRelatIDStruct.routeID = DB.getRouteID(RMStruct.routeCode, mainRelatIDStruct.trainDirectionID);
    if (mainRelatIDStruct.routeID == -1)
    {
        playPkgErr = ROUTEIDERR;
        return playPkgErr;
    }

    mainRelatIDStruct.staionID = DB.getStationID(RMStruct.currentStationCode, mainRelatIDStruct.routeID);
#ifdef DEBUG
    qDebug() << " mainRelatIDStruct.staionID" <<  mainRelatIDStruct.staionID << RMStruct.currentStationCode << mainRelatIDStruct.routeID;
#endif

    if (mainRelatIDStruct.staionID == -1)
    {
        playPkgErr = STATIONIDERR;
        return playPkgErr;
    }

    mainRelatIDStruct.trainStatusID = RMStruct.trainStatusID;

    if (mainRelatIDStruct.trainStatusID == -1)
    {
        playPkgErr = STATUSIDERR;
        return playPkgErr;
    }
    mainRelatIDStruct.positionInCarID = RMStruct.positionIncar;

#ifdef DEBUG
    qDebug() << routeMsgStruct.trainStatusID << "RouteID:" << mainRelatIDStruct.routeID << "staionID:" << mainRelatIDStruct.staionID << "trainDirectionID:" << mainRelatIDStruct.trainDirectionID << "\npositionInCarID:" \
                << mainRelatIDStruct.positionInCarID << "trainStatusID:" << mainRelatIDStruct.trainStatusID;
#endif

    DB.getPkgCustomPkgID(mainRelatIDStruct);
    if (mainRelatIDStruct.usrPkgList.count() < 1)
    {
        playPkgErr = USEPKGERR;
        return USEPKGERR;
    }

    for(int usrPkgIndex = 0; usrPkgIndex < mainRelatIDStruct.usrPkgList.count(); usrPkgIndex++)
    {
        routePkgStructList.clear();
        PkgRelatStructList.clear();

        //取得 用户自定义内容包列表，接下一步一步分析
        int playTime = 0;

        PkgRelatStructList = DB.getPkgRelatStructList(mainRelatIDStruct.usrPkgList.at(usrPkgIndex).pkgID);
        if (PkgRelatStructList.count() == 0)
        {
            playPkgErr = PKGRELATERR;
            continue;
        }
        RoutePkgStruct routePkgStruct;
        QList<UsrInfoStru > usrInfoList;
        QList<HoliInfoStruct > holiInfoList;


        LayoutStruct layoutStruct;               //布局结构体
        PkgRelatStruct pkgRelatStruct;

        //取得当前日期
        QDate date;
        QString currentDate = date.currentDate().toString("yyyyMMdd");

        //将包列表得到播放布局和内容的结构体

        int partionPlayTime = 0; //一个分区间有多个布局，这个是每个分局的播放时间
        for(int pkgIndex = 0; pkgIndex < PkgRelatStructList.count(); pkgIndex++)
        {
            //得到包结构体
            pkgRelatStruct = PkgRelatStructList.at(pkgIndex);


            //得到 布局结构体
            layoutStruct = DB.getLayoutStruct(pkgRelatStruct.layoutID, pkgRelatStruct.partitionID);


            //得到 自定义播放内容信息结构体 和 节假日信息结构体
            usrInfoList = DB.getUsrInfoStruList(pkgRelatStruct.contentID);
            holiInfoList = DB.getHoliInfoStructList(pkgRelatStruct.holidayContentID, currentDate);


            //如果找到播放内容那么即忽略此contentID,进入下一个内容查找
            if (usrInfoList.count() == 0)
            {
                //查看是否已经有布局无配置
                if (playPkgErr == LOSTLAYOUTWARIN)
                {
                    playPkgErr = LOSTLAYCNTWARIN;
                } else if (playPkgErr != LOSTLAYCNTWARIN)
                {
                    playPkgErr = LOSTCONTENTWARIN;
                }
            }

            //如果找到播放内容的layout,那么即忽略此contentID,进入下一个内容查找
            if (layoutStruct.partitionID == -1)
            {
                //查看是否已经有播放内容无配置
                if (playPkgErr == LOSTCONTENTWARIN)
                {
                    playPkgErr = LOSTLAYCNTWARIN;
                } else if (playPkgErr != LOSTLAYCNTWARIN)
                {
                    playPkgErr = LOSTLAYOUTWARIN;
                }
            }

            //从两个信息结构体和到播放列表
            if (holiInfoList.isEmpty())
            {
                routePkgStruct.contentStructList =  this->sortOnlyUsrCntList(usrInfoList);
            } else {
                routePkgStruct.contentStructList = this->sortHoliAndUsrCntList(usrInfoList, holiInfoList);
             }


            //是否没设置playtime,即一个布局的总播放时间
            //计算一个布局总的播放时间，如果有无限循环，那么时间定为一天
            for(int k = 0; k < routePkgStruct.contentStructList.count(); k++)
            {
                if (routePkgStruct.contentStructList.at(k).duration != 0 && routePkgStruct.contentStructList.at(k).isUnlimited)
                {
                    partionPlayTime = 60 * 60 * 24;
                } else {
                    partionPlayTime += routePkgStruct.contentStructList.at(k).duration;
                }
            }

            //将布局结构体和播放列表放到播放包结构体
            routePkgStruct.layoutStruct = layoutStruct;

            //如果没有播放内容的话，类型即固定为-1
            if (routePkgStruct.contentStructList.count() == 0)
            {
                routePkgStruct.contentTypeID = -1;
            } else {
                routePkgStruct.contentTypeID = routePkgStruct.contentStructList.at(0).contentTypeID;
            }

            routePkgStructList.append(routePkgStruct);

            //如果一个Layout有多个布局，选出播放时间最长的为总的播放时间
            if (playTime < partionPlayTime)
                playTime = partionPlayTime;
            partionPlayTime = 0;
        }

//        routePkgList = routePkgStructList;
        RoutePkgList pkgCntList;
        pkgCntList.playTime = 0;
        pkgCntList.routePkgList = routePkgStructList;

        //每一个布局播放时间都可以设定，如果没设定，那么就将布局内分区最长的播放时间设定为此布局的播放时间
        if (mainRelatIDStruct.usrPkgList.at(usrPkgIndex).interval != 0)
        {
            pkgCntList.playTime = mainRelatIDStruct.usrPkgList.at(usrPkgIndex).interval;
        } else {
            pkgCntList.playTime = playTime;
        }

        routePkgList.append(pkgCntList);
        playPkgErr = NOERR;
    }

    /*
    包                   ---- 布局                     ---- 分区             ---- 播放列表

    QList<RoutePkgList>  ----RoutePkgList             ---- RoutePkgStruct   ---- QList<ContentStruct>

    1个包内包含多个布局，1个布局包含多个分区，1个分区内包含多条播放列表
    */

//    QList<RoutePkgStruct> pkgList;
//    for(int i = 0; i < routePkgList.count(); i++)
//    {
//        pkgList = routePkgList.at(i).routePkgList;
//        qDebug() << "i:" << i;
//        for(int j = 0; j < pkgList.count(); j++)
//        {
//            RoutePkgStruct stRoutePkg = pkgList.at(j);
//            LayoutStruct stLayout = stRoutePkg.layoutStruct;
//            QList<ContentStruct> stCntList = stRoutePkg.contentStructList;
//            qDebug() << "j:" << j << "stLayout:" << stLayout.partitionID;
//            for(int k = 0; k < stCntList.count(); k++)
//            {
//                ContentStruct stContent = stCntList.at(k);
//                qDebug() << k << "stContent:" << stContent.contentFile << stContent.duration << stContent.isUnlimited;
//            }
//        }
//    }

    return playPkgErr;
}


/*******************************************
  功能：得到播放包列表
  参数：routeMsgStruct，线路信息结构体,提供线路的基本信息
  返回值：得到播放包列表
  ******************************************/
PLAYPKGERR RouteDB::getDefaultPlayPkgList(QList<RoutePkgList>& routePkgList, const RouteMsgStruct& routeMsgStruct) const
{
    QList<PkgRelatStruct> PkgRelatStructList;
    QList<RoutePkgStruct> routePkgStructList;

    MainRelatIDStruct mainRelatIDStruct;
    RouteMsgStruct RMStruct = routeMsgStruct;
    PLAYPKGERR playPkgErr = NOERR;


    if (routeMsgStruct.routeCode == "0")
    {
        mainRelatIDStruct.routeID = routeMsgStruct.routeCode.toInt();
    } else {
        //先完善 线路信息ID结构体
        mainRelatIDStruct.trainDirectionID = DB.getTrainDirectID(RMStruct.routeCode);

        mainRelatIDStruct.routeID = DB.getRouteID(RMStruct.routeCode, mainRelatIDStruct.trainDirectionID);

        if (mainRelatIDStruct.routeID == -1)
        {
            playPkgErr = ROUTEIDERR;
            return playPkgErr;
        }

        mainRelatIDStruct.positionInCarID = RMStruct.positionIncar;
    }
    DB.getPkgDefaultPkgID(mainRelatIDStruct);

    if (mainRelatIDStruct.defaultPkgList.count() < 1)
    {
        playPkgErr = USEPKGERR;
        return playPkgErr;
    }

    int partionPlayTime = 0; //一个分区间有多个布局，这个是每个分局的播放时间
    for(int defaultPkgIndex = 0; defaultPkgIndex < mainRelatIDStruct.defaultPkgList.count(); defaultPkgIndex++)
    {
        routePkgStructList.clear();
        PkgRelatStructList.clear();

        int playTime = 0;
        //取得默认内容包列表，接下一步一步分析（自定义表和默认表的区别只在于此处，其它方面都相同）
        PkgRelatStructList = DB.getPkgRelatStructList(mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).pkgID);

        if (PkgRelatStructList.count() == 0)
        {
            playPkgErr = PKGRELATERR;
            continue;
        }

        RoutePkgStruct routePkgStruct;
        QList<UsrInfoStru > usrInfoList;
        QList<HoliInfoStruct > holiInfoList;

        LayoutStruct layoutStruct;               //布局结构体
        PkgRelatStruct pkgRelatStruct;

        //取得当前日期 添加:查找不到内容错误检测和播放分区查找不到错误检测，它们的返回
        QDate date;
        QString currentDate = date.currentDate().toString("yyyyMMdd");

        //将包列表得到播放布局和内容的结构体
        for(int pkgIndex = 0; pkgIndex < PkgRelatStructList.count(); pkgIndex++)
        {
            //得到包结构体
            pkgRelatStruct = PkgRelatStructList.at(pkgIndex);

            //得到 布局结构体
            layoutStruct = DB.getLayoutStruct(pkgRelatStruct.layoutID, pkgRelatStruct.partitionID);

            //得到 自定义播放内容信息结构体 和 节假日信息结构体
            usrInfoList = DB.getUsrInfoStruList(pkgRelatStruct.contentID);
            holiInfoList = DB.getHoliInfoStructList(pkgRelatStruct.holidayContentID, currentDate);

            for(int k = 0; k < usrInfoList.count(); k++)
            {
                if (usrInfoList.at(k).cntStruct.duration > playTime)
                    playTime = usrInfoList.at(k).cntStruct.duration;
            }

            for(int k = 0; k < holiInfoList.count(); k++)
            {
                if (holiInfoList.at(k).cntStruct.duration > playTime)
                    playTime = holiInfoList.at(k).cntStruct.duration;
            }

            //如果找到播放内容那么即忽略此contentID,进入下一个内容查找
            if (usrInfoList.count() == 0)
            {
                //查看是否已经有布局无配置
                if (playPkgErr == LOSTLAYOUTWARIN)
                {
                    playPkgErr = LOSTLAYCNTWARIN;
                } else if (playPkgErr != LOSTLAYCNTWARIN)
                {
                    playPkgErr = LOSTCONTENTWARIN;
                }
            }

            //如果找到播放内容的layout,那么即忽略此contentID,进入下一个内容查找
            if (layoutStruct.partitionID == -1)
            {
                //查看是否已经有播放内容无配置
                if (playPkgErr == LOSTCONTENTWARIN)
                {
                    playPkgErr = LOSTLAYCNTWARIN;
                } else if (playPkgErr != LOSTLAYCNTWARIN)
                {
                    playPkgErr = LOSTLAYOUTWARIN;
                }
            }

            //从两个信息结构体和到播放列表
            if (holiInfoList.isEmpty())
            {
                routePkgStruct.contentStructList =  this->sortOnlyUsrCntList(usrInfoList);
            } else {
                routePkgStruct.contentStructList = this->sortHoliAndUsrCntList(usrInfoList, holiInfoList);
            }

            //是否没设置playtime,即一个布局的总播放时间
            //计算一个布局总的播放时间，如果有无限循环，那么时间定为一天
            for(int contentStIndex = 0; contentStIndex < routePkgStruct.contentStructList.count(); contentStIndex++)
            {
                if (routePkgStruct.contentStructList.at(contentStIndex).duration != 0 && routePkgStruct.contentStructList.at(contentStIndex).isUnlimited)
                {
                    partionPlayTime = 60 * 60 * 24;
                } else {
                    partionPlayTime += routePkgStruct.contentStructList.at(contentStIndex).duration;
                }
            }

            //将布局结构体和播放列表放到播放包结构体
            routePkgStruct.layoutStruct = layoutStruct;

            //如果没有播放内容的话，类型即固定为-1
            if (routePkgStruct.contentStructList.count() == 0)
            {
                routePkgStruct.contentTypeID = -1;
            } else {
                routePkgStruct.contentTypeID = routePkgStruct.contentStructList.at(0).contentTypeID;
            }

            routePkgStructList.append(routePkgStruct);

            //如果一个Layout有多个布局，选出播放时间最长的为总的播放时间
            if (playTime < partionPlayTime)
                playTime = partionPlayTime;
            partionPlayTime = 0;
        }

        RoutePkgList pkgCntList;
        pkgCntList.routePkgList = routePkgStructList;

//        qDebug() << "...........>>>" << mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).interval;
        //每一个布局播放时间都可以设定，如果没设定，那么就将布局内分区最长的播放时间设定为此布局的播放时间
        if (mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).interval != 0)
        {
            pkgCntList.playTime = mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).interval;
        } else {
            pkgCntList.playTime = playTime;
        }



        routePkgList.append(pkgCntList);
        playPkgErr = NOERR;
    }
    return playPkgErr;
}


PLAYPKGERR RouteDB::getCePlayPkgList(QList<RoutePkgList>& routePkgList, const CeRouteMsg& routeMsgStruct) const
{
    //    qDebug() << "getReviewPlayPkgList===>" << routeMsgStruct.currentStationCode << routeMsgStruct.positionIncar << routeMsgStruct.routeCode << routeMsgStruct.trainStatusID;
        QList<PkgRelatStruct> PkgRelatStructList;
        QList<RoutePkgStruct> routePkgStructList;

        MainRelatIDStruct mainRelatIDStruct;
        CeRouteMsg RMStruct = routeMsgStruct;
        PLAYPKGERR playPkgErr = NOERR;

        mainRelatIDStruct.positionInCarID = RMStruct.positionIncar;
        mainRelatIDStruct.routeID = RMStruct.routeID;
        mainRelatIDStruct.staionID = RMStruct.stationID;
        mainRelatIDStruct.trainDirectionID = RMStruct.directionID;
        mainRelatIDStruct.trainStatusID = RMStruct.status;

//        qDebug() << "routeID ==" << mainRelatIDStruct.routeID << mainRelatIDStruct.staionID << mainRelatIDStruct.trainDirectionID << mainRelatIDStruct.trainStatusID << mainRelatIDStruct.positionInCarID;

        if (mainRelatIDStruct.routeID == -1)
        {
            playPkgErr = ROUTEIDERR;
            return playPkgErr;
        }

        DB.getPkgCustomPkgID(mainRelatIDStruct);
        if (mainRelatIDStruct.usrPkgList.count() < 1)
        {
            playPkgErr = USEPKGERR;
            return playPkgErr;
        }

//        for(int i = 0; i < mainRelatIDStruct.usrPkgList.count(); i++)
        for(int usrPkgIndex = 0; usrPkgIndex < mainRelatIDStruct.usrPkgList.count(); usrPkgIndex++)
        {
            routePkgStructList.clear();
            PkgRelatStructList.clear();

            int playTime = 0;

            //取得 用户自定义内容包列表，接下一步一步分析
//            PkgRelatStructList = DB.getPkgRelatStructList(mainRelatIDStruct.usrPkgList.at(i).pkgID);
            PkgRelatStructList = DB.getPkgRelatStructList(mainRelatIDStruct.usrPkgList.at(usrPkgIndex).pkgID);

            if (PkgRelatStructList.count() == 0)
            {
                playPkgErr = PKGRELATERR;
                continue;
            }
            RoutePkgStruct routePkgStruct;
            QList<UsrInfoStru > usrInfoList;
            QList<HoliInfoStruct > holiInfoList;


            LayoutStruct layoutStruct;               //布局结构体
            PkgRelatStruct pkgRelatStruct;

            //取得当前日期
            QDate date;
            QString currentDate = date.currentDate().toString("yyyyMMdd");

            //将包列表得到播放布局和内容的结构体
            int partionPlayTime = 0; //一个分区间有多个布局，这个是每个分局的播放时间
//            for(int i = 0; i < PkgRelatStructList.count(); i++)
            for(int pkgIndex = 0; pkgIndex < PkgRelatStructList.count(); pkgIndex++)
            {
                //得到包结构体
                pkgRelatStruct = PkgRelatStructList.at(pkgIndex);


                //得到 布局结构体
                layoutStruct = DB.getLayoutStruct(pkgRelatStruct.layoutID, pkgRelatStruct.partitionID);

                //得到 自定义播放内容信息结构体 和 节假日信息结构体
                usrInfoList = DB.getUsrInfoStruList(pkgRelatStruct.contentID);

                holiInfoList = DB.getHoliInfoStructList(pkgRelatStruct.holidayContentID, currentDate);

                for(int k = 0; k < usrInfoList.count(); k++)
                {
                    if (usrInfoList.at(k).cntStruct.duration > playTime)
                        playTime = usrInfoList.at(k).cntStruct.duration;
                }
                for(int k = 0; k < holiInfoList.count(); k++)
                {
                    if (holiInfoList.at(k).cntStruct.duration > playTime)
                        playTime = holiInfoList.at(k).cntStruct.duration;
                }

                //如果找到播放内容那么即忽略此contentID,进入下一个内容查找
                if (usrInfoList.count() == 0)
                {
                    //查看是否已经有布局无配置
                    if (playPkgErr == LOSTLAYOUTWARIN)
                    {
                        playPkgErr = LOSTLAYCNTWARIN;
                    } else if (playPkgErr != LOSTLAYCNTWARIN)
                    {
                        playPkgErr = LOSTCONTENTWARIN;
                    }
                }                

                //如果找到播放内容的layout,那么即忽略此contentID,进入下一个内容查找
                if (layoutStruct.partitionID == -1)
                {
                    //查看是否已经有播放内容无配置
                    if (playPkgErr == LOSTCONTENTWARIN)
                    {
                        playPkgErr = LOSTLAYCNTWARIN;
                    } else if (playPkgErr != LOSTLAYCNTWARIN)
                    {
                        playPkgErr = LOSTLAYOUTWARIN;
                    }
                }

                //从两个信息结构体和到播放列表
                if (holiInfoList.isEmpty())
                {
                    routePkgStruct.contentStructList =  this->sortOnlyUsrCntList(usrInfoList);
                } else {
                    routePkgStruct.contentStructList = this->sortHoliAndUsrCntList(usrInfoList, holiInfoList);
                 }

                //是否没设置playtime,即一个布局的总播放时间
                //计算一个布局总的播放时间，如果有无限循环，那么时间定为一天
                for(int k = 0; k < routePkgStruct.contentStructList.count(); k++)
                {
                    if (routePkgStruct.contentStructList.at(k).duration != 0 && routePkgStruct.contentStructList.at(k).isUnlimited)
                    {
                        partionPlayTime = 60 * 60 * 24;
                    } else {
                        partionPlayTime += routePkgStruct.contentStructList.at(k).duration;
                    }
                }

                //将布局结构体和播放列表放到播放包结构体
                routePkgStruct.layoutStruct = layoutStruct;

                //如果没有播放内容的话，类型即固定为-1
                if (routePkgStruct.contentStructList.count() == 0)
                {
                    routePkgStruct.contentTypeID = -1;
                } else {
                    routePkgStruct.contentTypeID = routePkgStruct.contentStructList.at(0).contentTypeID;
                }
//a
                routePkgStructList.append(routePkgStruct);

                //如果一个Layout有多个布局，选出播放时间最长的为总的播放时间
                if (playTime < partionPlayTime)
                    playTime = partionPlayTime;
                partionPlayTime = 0;
            }

            RoutePkgList pkgCntList;
            pkgCntList.routePkgList = routePkgStructList;

            //每一个布局播放时间都可以设定，如果没设定，那么就将布局内分区最长的播放时间设定为此布局的播放时间
            if (mainRelatIDStruct.usrPkgList.at(usrPkgIndex).interval != 0)
                pkgCntList.playTime = mainRelatIDStruct.usrPkgList.at(usrPkgIndex).interval;
            else
                pkgCntList.playTime = playTime;

            routePkgList.append(pkgCntList);
            playPkgErr = NOERR;
        }
        return playPkgErr;
}

PLAYPKGERR RouteDB::getCeDefaultPlayPkgList(QList<RoutePkgList>& routePkgList, const CeRouteMsg& routeMsgStruct) const
{
    QList<PkgRelatStruct> PkgRelatStructList;
    QList<RoutePkgStruct> routePkgStructList;

    MainRelatIDStruct mainRelatIDStruct;
    CeRouteMsg RMStruct = routeMsgStruct;
    PLAYPKGERR playPkgErr = NOERR;

    mainRelatIDStruct.positionInCarID = RMStruct.positionIncar;
    mainRelatIDStruct.routeID = RMStruct.routeID;
    mainRelatIDStruct.staionID = RMStruct.stationID;
    mainRelatIDStruct.trainDirectionID = RMStruct.directionID;
    mainRelatIDStruct.trainStatusID = RMStruct.status;

    DB.getPkgDefaultPkgID(mainRelatIDStruct);

    if (mainRelatIDStruct.defaultPkgList.count() < 1)
    {
        playPkgErr = USEPKGERR;
        return playPkgErr;
    }

//    for(int i = 0; i < mainRelatIDStruct.defaultPkgList.count(); i++)
    for(int defaultPkgIndex = 0; defaultPkgIndex < mainRelatIDStruct.defaultPkgList.count(); defaultPkgIndex++)
    {
        routePkgStructList.clear();
        PkgRelatStructList.clear();

        int playTime = 0;
        //取得默认内容包列表，接下一步一步分析（自定义表和默认表的区别只在于此处，其它方面都相同）
        PkgRelatStructList = DB.getPkgRelatStructList(mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).pkgID);

        if (PkgRelatStructList.count() == 0)
        {
            playPkgErr = PKGRELATERR;
            continue;
//            return playPkgErr;
        }

        RoutePkgStruct routePkgStruct;
        QList<UsrInfoStru > usrInfoList;
        QList<HoliInfoStruct > holiInfoList;

        LayoutStruct layoutStruct;               //布局结构体
        PkgRelatStruct pkgRelatStruct;

        //取得当前日期 添加:查找不到内容错误检测和播放分区查找不到错误检测，它们的返回
        QDate date;
        QString currentDate = date.currentDate().toString("yyyyMMdd");

        //将包列表得到播放布局和内容的结构体
        int partionPlayTime = 0; //一个分区间有多个布局，这个是每个分局的播放时间
//        for(int i = 0; i < PkgRelatStructList.count(); i++)
        for(int pkgIndex = 0; pkgIndex < PkgRelatStructList.count(); pkgIndex++)
        {
            //得到包结构体
            pkgRelatStruct = PkgRelatStructList.at(pkgIndex);

            //得到 布局结构体
            layoutStruct = DB.getLayoutStruct(pkgRelatStruct.layoutID, pkgRelatStruct.partitionID);

            //得到 自定义播放内容信息结构体 和 节假日信息结构体
            usrInfoList = DB.getUsrInfoStruList(pkgRelatStruct.contentID);
            holiInfoList = DB.getHoliInfoStructList(pkgRelatStruct.holidayContentID, currentDate);

            for(int k = 0; k < usrInfoList.count(); k++)
            {
                if (usrInfoList.at(k).cntStruct.duration > playTime)
                    playTime = usrInfoList.at(k).cntStruct.duration;
            }
            for(int k = 0; k < holiInfoList.count(); k++)
            {
                if (holiInfoList.at(k).cntStruct.duration > playTime)
                    playTime = holiInfoList.at(k).cntStruct.duration;
            }

            //如果找到播放内容那么即忽略此contentID,进入下一个内容查找
            if (usrInfoList.count() == 0)
            {
                //查看是否已经有布局无配置
                if (playPkgErr == LOSTLAYOUTWARIN)
                {
                    playPkgErr = LOSTLAYCNTWARIN;
                } else if (playPkgErr != LOSTLAYCNTWARIN)
                {
                    playPkgErr = LOSTCONTENTWARIN;
                }
            }

            //如果找到播放内容的layout,那么即忽略此contentID,进入下一个内容查找
            if (layoutStruct.partitionID == -1)
            {
                //查看是否已经有播放内容无配置
                if (playPkgErr == LOSTCONTENTWARIN)
                {
                    playPkgErr = LOSTLAYCNTWARIN;
                } else if (playPkgErr != LOSTLAYCNTWARIN)
                {
                    playPkgErr = LOSTLAYOUTWARIN;
                }
            }

            //从两个信息结构体和到播放列表
            if (holiInfoList.isEmpty())
            {
                routePkgStruct.contentStructList =  this->sortOnlyUsrCntList(usrInfoList);
            } else {
                routePkgStruct.contentStructList = this->sortHoliAndUsrCntList(usrInfoList, holiInfoList);
            }

            //是否没设置playtime,即一个布局的总播放时间
            //计算一个布局总的播放时间，如果有无限循环，那么时间定为一天
            for(int k = 0; k < routePkgStruct.contentStructList.count(); k++)
            {
                if (routePkgStruct.contentStructList.at(k).duration != 0 && routePkgStruct.contentStructList.at(k).isUnlimited)
                {
                    partionPlayTime = 60 * 60 * 24;
                } else {
                    partionPlayTime += routePkgStruct.contentStructList.at(k).duration;
                }
            }

            //将布局结构体和播放列表放到播放包结构体
            routePkgStruct.layoutStruct = layoutStruct;

            //如果没有播放内容的话，类型即固定为-1
            if (routePkgStruct.contentStructList.count() == 0)
            {
                routePkgStruct.contentTypeID = -1;
            } else {
                routePkgStruct.contentTypeID = routePkgStruct.contentStructList.at(0).contentTypeID;
            }

            routePkgStructList.append(routePkgStruct);

            //如果一个Layout有多个布局，选出播放时间最长的为总的播放时间
            if (playTime < partionPlayTime)
                playTime = partionPlayTime;
            partionPlayTime = 0;
        }

        RoutePkgList pkgCntList;
        pkgCntList.routePkgList = routePkgStructList;

        //每一个布局播放时间都可以设定，如果没设定，那么就将布局内分区最长的播放时间设定为此布局的播放时间
        if (mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).interval != 0)
            pkgCntList.playTime = mainRelatIDStruct.defaultPkgList.at(defaultPkgIndex).interval;
        else
            pkgCntList.playTime = playTime;

        routePkgList.append(pkgCntList);
        playPkgErr = NOERR;
    }

    return playPkgErr;
}

/***************************************************

                    删除内容接口

 ***************************************************/


/*******************************************
  功能：设置 线路站点状态对应关系表 内容
  参数：mainRelatIDStruct： 要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setMainRelatTableCnt(const MainRelatIDStruct& mainRelatIDStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesMainRelatTable(mainRelatIDStruct);
    bRep = DB.replaceLineMainRelatTable(mainRelatIDStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 布局表 内容
  参数：layoutStruct： 要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setLayoutTableCnt(const LayoutStruct& layoutStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesLayoutTable(layoutStruct.layoutID, layoutStruct.partitionID);
    bRep = DB.replaceLineLayoutTable(layoutStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 包关系表 内容
  参数：pkgRelatStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setPkgRelatTableCnt(const PkgRelatStruct &pkgRelatStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesPkgRelatTable(pkgRelatStruct.pkgID);
    bRep = DB.replaceLinePkgRelationTable(pkgRelatStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 包定义表 内容
  参数：pkgDesStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setPkgDesTableCnt(const PkgDesStruct &pkgDesStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesPkgDesTable(pkgDesStruct.pkgID);
    bRep = DB.replaceLinePkgDesTable(pkgDesStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 节假日内容关系表 内容
  参数：holidayCntStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setHoliCntRelatTableCnt(const ContentStruct &holidayCntStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesHoliCntDesTable(holidayCntStruct.contentID);
    bRep = DB.replaceLineHoliCntRelatTable(holidayCntStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 节假日内容定义表 内容
  参数：holiDesStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setHoliCntDesTableCnt(const HoliDesStruct &holiDesStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesHoliCntDesTable(holiDesStruct.holidayContentID);
    bRep = DB.replaceLineHoliCntDesTable(holiDesStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 播放方式字典表 内容
  参数：holiPlayModStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setPlayModeTableCnt(const HoliPlayModStruct &holiPlayModStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesPlayModeTable(holiPlayModStruct.playModelID);
    bRep = DB.replaceLinePlayModeTable(holiPlayModStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 自定义内容关系表 内容
  参数：usrContentStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setUsrCntRelatTableCnt(const ContentStruct &usrContentStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesUsrCntRelatTable(usrContentStruct.contentID);
    bRep = DB.replaceLineUsrCntRelatTable(usrContentStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 自定义内容定义表 内容
  参数：usrCntDesStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setUsrCntDesTableCnt(const UsrCntDesStruct &usrCntDesStruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesUsrCntDesTable(usrCntDesStruct.contentID);
    bRep = DB.replaceLineUsrCntDesTable(usrCntDesStruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 内容类型字典表 内容
  参数：usrCntTypestruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setUsrCntTypeTableCnt(UsrCntTypeStruct usrCntTypestruct) const
{
    bool bRep;

    //先删除后添加
    DB.delLinesUsrCntTypeTable(usrCntTypestruct.contentTypeID);
    bRep = DB.replaceLineUsrCntTypeTable(usrCntTypestruct);

    if (bRep)
    {
        return true;
    } else {
        return false;
    }
}



/*******************************************
  功能：设置 节假日信息结构体 内容,它包含3个方面，
       节假日内容关系表，节假日内容定义表，播放方式字典表
  参数：holidayInfoStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setHolidayInfo(const HoliInfoStruct holidayInfoStruct) const
{
    //节假日描述结构体
    HoliDesStruct holiDesStr = holidayInfoStruct.holiDesModStruct.holiDesStru;

    //节假日描述结构体
    HoliPlayModStruct holiPlayModStruct = holidayInfoStruct.holiDesModStruct.holiPlayModStruct;            //节假日内容结构体

    //内容结构体
    ContentStruct cntStruct = holidayInfoStruct.cntStruct;

    if (!this->setHoliCntDesTableCnt(holiDesStr))
        return false;


    if (!this->setPlayModeTableCnt(holiPlayModStruct))
        return false;

    if (!this->setHoliCntRelatTableCnt(cntStruct))
        return false;

    return true;

}

/***************************************************

                    删除内容接口

 ***************************************************/


/*******************************************
  功能：删除 线路站点状态对应关系表 内容
  参数：mainRelatIDStruct:要删除的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delMainRelatTableCnt(const MainRelatIDStruct &mainRelatIDStruct) const
{
    bool bDel;

    bDel = DB.delLinesMainRelatTable(mainRelatIDStruct);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：设置 自定义播放内容信息 内容,它包含3个方面，
       内容关系表，内容定义表，内容类型字典表
  参数：usrInfoStruct:要设置的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::setUsrInfo(const UsrInfoStru usrInfoStruct) const
{
     //自定义内容描述结构体
    UsrCntDesStruct usrCntDesStruct = usrInfoStruct.usrCntDesStruct;

    //内容结构体
    ContentStruct cntStruct = usrInfoStruct.cntStruct;

    //自定义播放内容信息结构体
    UsrCntTypeStruct usrCntTypeStruct = usrInfoStruct.usrCntTypeStruct;



    if (!this->setUsrCntDesTableCnt(usrCntDesStruct))
        return false;

    if (!this->setUsrCntTypeTableCnt(usrCntTypeStruct))
        return false;

    if (!this->setUsrCntRelatTableCnt(cntStruct))
        return false;

    return true;
}




/*******************************************
  功能：删除 布局表 内容
  参数：layoutID:布局ID partitionID:分区ID
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delLayoutTableCnt(const int layoutID, const int partitionID) const
{
    bool bDel;

    bDel = DB.delLinesLayoutTable(layoutID, partitionID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 包关系表 内容
  参数：packageID:要删除的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delPkgRelatTableCnt(const int packageID) const
{
    bool bDel;

    bDel = DB.delLinesPkgRelatTable(packageID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 包定义表 内容
  参数：packageID:要删除内容的ID
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delPkgDesTableCnt(const int packageID) const
{
    bool bDel;

    bDel = DB.delLinesPkgDesTable(packageID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 节假日内容关系表 内容
  参数：holidayContentID:要删除的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delHoliCntRelatTableCnt(const int holidayContentID, const QString &holiday) const
{
    bool bDel;

    bDel = DB.delLinesHoliCntRelatTable(holidayContentID, holiday);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 节假日内容定义表 内容
  参数：contentID:要删除的内容
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delHoliCntDesTableCnt(const int contentID) const
{
    bool bDel;

    bDel = DB.delLinesHoliCntDesTable(contentID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 播放方式字典表 内容
  参数：playModeID:要删除的内容播放方式ID
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delPlayModeTableCnt(const int playModeID) const
{
    bool bDel;

    bDel = DB.delLinesPlayModeTable(playModeID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}


/*******************************************
  功能：删除 自定义内容关系表 内容
  参数：contentID:内容ID号
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delUsrCntRelatTableCnt(const int contentID) const
{
    bool bDel;

    bDel = DB.delLinesUsrCntRelatTable(contentID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 自定义内容定义表 内容
  参数：contentID:内容ID号
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delUsrCntDesTableCnt(const int contentID) const
{
    bool bDel;

    bDel = DB.delLinesUsrCntDesTable(contentID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：删除 内容类型字典表 内容
  参数：contentTypeID:内容ID号
  返回值：正确设置返回true 否则返回false
  ******************************************/
bool RouteDB::delUsrCntTypeTableCnt(const int contentTypeID) const
{
    bool bDel;

    bDel = DB.delLinesUsrCntTypeTable(contentTypeID);

    if (bDel)
    {
        return true;
    } else {
        return false;
    }
}


/***************************************************

                    私有函数

 ***************************************************/


/*******************************************
  功能：排列播放内容包的列表,只有自定义内容
  参数：usrCntStructList:自定义内容列表
  返回值：播放内容列表
  ******************************************/
QList<ContentStruct> RouteDB::sortOnlyUsrCntList(const QList<UsrInfoStru> &usrInfoStructList) const
{
    QList<ContentStruct> playCntList;

    QList<UsrInfoStru> usrInfoList = usrInfoStructList;

    ContentStruct usrCntStruct;
    UsrCntDesStruct usrCntDesStruct;       //自定义内容描述结构体

    int cntListCount = usrInfoList.count();
    int flagCount = cntListCount;

    if (usrInfoStructList.count() == 0)
    {
        return playCntList;
    }

    //将列表播放内容遍历一遍
    for (int i = 0; i < usrInfoList.count(); i++)
    {
        usrCntStruct = usrInfoList.at(i).cntStruct;
        usrCntDesStruct = usrInfoList.at(i).usrCntDesStruct;

        //如果repeatFlag不为0，则证明此内容要播放多次，每添加一次，则把repeatTimes减一
        //则到repeatFlag为0，则证明已经该内容只需要播放一次就行了
        if (usrCntStruct.repeatFlag != 0)
        {
//            if (usrCntStruct.repeatFlag < -1)
//            {
//                usrCntStruct.repeatFlag = 0;
//                continue;
//            }

            playCntList.append(usrCntStruct);

            if (!usrCntStruct.isUnlimited)
            {
                usrInfoList[i].usrCntDesStruct.repeatTimes = usrInfoList.at(i).usrCntDesStruct.repeatTimes - 1;
                usrCntDesStruct.repeatTimes--;
            }


            //当播放次数为0，则证明不需要此播放内容，故在usrCntList中删除该内容
            if (usrCntDesStruct.repeatTimes <= -1 && usrCntStruct.isUnlimited == false)
            {
                usrInfoList.removeAt(i);
                cntListCount--;
                flagCount--;
                i--;
            }
        } else {
            usrCntStruct.isUnlimited = false;
            //添加时播放列表，然后将此内内容在待分配表中删除
            playCntList.append(usrCntStruct);

            usrInfoList.removeAt(i);
            cntListCount--;
            flagCount--;
            i--;
        }


        //当所有自定义内容都已经加入到播放列表中时，则退出自定义列表遍历循环
        //否则当到遍历到最后一个时则返回第一个，重新遍历
        if (i >= (usrInfoList.count() - 1))
        {
            //如果此时没有非unlimited多次播放的话，则证明播放列表已经编排成功
            bool isFind = false;
            for(int k = 0; k < usrInfoList.count(); k++)
            {
                if (usrInfoList.at(k).cntStruct.isUnlimited == false && usrInfoList.at(k).usrCntDesStruct.repeatTimes > 0)
                {
                    isFind = true;
                }
            }

            if (!isFind)
            {
               break;
            } else {
                i = -1;
            }
        }

    }

//    for(int i = 0; i < playCntList.count(); i++)
//    {
//        qDebug() << i << "playCntList===" << playCntList.at(i).contentFile;
//    }
    return playCntList;
}

/*******************************************
  功能：排列播放内容包的列表,当有自定义内容和节假日时
  参数：usrCntStructList:自定义内容列表
       holiCntStructList:节假日内容列表
  返回值：播放内容列表
  ******************************************/
QList<ContentStruct> RouteDB::sortHoliAndUsrCntList(const QList<UsrInfoStru> &usrInfoStructList,
                                               const QList<HoliInfoStruct> &holiInfoStructList) const
{
    QList<ContentStruct> playCntList;

    QList<UsrInfoStru> usrInfoList = usrInfoStructList;
    QList<HoliInfoStruct> holiInfoList = holiInfoStructList;

    ContentStruct usrCntStruct;
    UsrCntDesStruct usrCntDesStruct;       //自定义内容描述结构体

    ContentStruct holicntStruct;
    HoliPlayModStruct holiPlayModStruct;


    int cntListCount = usrInfoList.count();
    int flagCount = cntListCount;

    for (int i = 0; i < cntListCount; i++)
    {
        usrCntStruct = usrInfoList.at(i).cntStruct;
        usrCntDesStruct = usrInfoList.at(i).usrCntDesStruct;

//        qDebug() << "usrCntStruct==========>" << usrCntStruct.contentFile;
        //如果repeatFlag不为0，则证明此内容要播放多次，每添加一次，则把repeatTimes减一
        //则到repeatFlag为0，则证明已经该内容只需要播放一次就行了
        if (usrCntStruct.repeatFlag != 0)
        {

                playCntList.append(usrCntStruct);

                if (!usrCntStruct.isUnlimited)
                {
                    usrInfoList[i].usrCntDesStruct.repeatTimes = usrInfoList.at(i).usrCntDesStruct.repeatTimes - 1;
                    usrCntDesStruct.repeatTimes--;
                }

                //当播放次数为0，则证明不需要此播放内容，故在usrCntList中删除该内容
                if (usrCntDesStruct.repeatTimes <= -1 && usrCntStruct.isUnlimited == false)
                {
                    usrInfoList.removeAt(i);
                    cntListCount--;
                    flagCount--;
                    i--;
                }

        } else {
            usrCntStruct.isUnlimited = false;
            //添加时播放列表，然后将此内内容在待分配表中删除
            playCntList.append(usrCntStruct);
            usrInfoList.removeAt(i);
            cntListCount--;
            flagCount--;
            i--;
        }

        //repeatFlag如果是节假日则相当于播放方式
        //playMode: 0,优先 1,最后 2,插入
        //
        //每添加一个自定义内容到列表时则要检查是否有节假日信息要插入到列表中
        for (int j = 0; j < holiInfoList.count(); j++)
        {
            holicntStruct = holiInfoList.at(j).cntStruct;
            holiPlayModStruct = holiInfoList.at(j).holiDesModStruct.holiPlayModStruct;

            if (holiPlayModStruct.playModelID < 1 || holiPlayModStruct.playModelID > 2)
            {
                //查找自定义的列表中如果有Unlimited播放内容，则将节假日的播放方式也设定为Unlimited
                for(int k = 0; k < usrInfoList.count(); k++)
                {
                    if (usrInfoList.at(k).cntStruct.isUnlimited == true)
                    {
                        holicntStruct.isUnlimited = true;
                        k = usrInfoList.count();
                    }
                }

                playCntList.insert(0, holicntStruct);
                holiInfoList.removeAt(j);
                j--;
            } else if (holiPlayModStruct.playModelID == 2)
            {
                //播放形式的节假日播放方式跟随它前一个播放方式，如果为Unlimited则节假日亦为Unlimited
                holicntStruct.isUnlimited = usrCntStruct.isUnlimited;
                playCntList.append(holicntStruct);
            }
        }

        //当所有自定义内容都已经加入到播放列表中时，则退出自定义列表遍历循环
        //否则当到遍历到最后一个时则返回第一个，重新遍历
//        if ((i >= (cntListCount - 1)) && (flagCount != 0))
        if (i >= (usrInfoList.count() - 1))
        {
            //如果此时没有非unlimited多次播放的话，则证明播放列表已经编排成功
            bool isFind = false;
            for(int k = 0; k < usrInfoList.count(); k++)
            {
                if (usrInfoList.at(k).cntStruct.isUnlimited == false && usrInfoList.at(k).usrCntDesStruct.repeatTimes > 0)
                {
                    isFind = true;
                }
            }

            if (!isFind)
            {
               break;
            } else {
                i = -1;
            }
        }
    }

    //接着继续检查是否有 最后播放方式 的节假日内容，有则添加到最后，
    //添加完仍旧删除此内容
    for (int j = 0; j < holiInfoList.count(); j++)
    {
        holicntStruct = holiInfoList.at(j).cntStruct;
        holiPlayModStruct = holiInfoList.at(j).holiDesModStruct.holiPlayModStruct;

        if (holiPlayModStruct.playModelID == 1)
        {
            //查找自定义的列表中如果有Unlimited播放内容，则将节假日的播放方式也设定为Unlimited
            for(int k = 0; k < usrInfoList.count(); k++)
            {
                if (usrInfoList.at(k).cntStruct.isUnlimited == true)
                {
//                    qDebug() << "holicntStruct===========" << usrInfoList.at(k).cntStruct.contentFile;
                    holicntStruct.isUnlimited = true;
                    k = usrInfoList.count();
                } else {
                    holicntStruct.isUnlimited = false;
                }
            }

            playCntList.append(holicntStruct);
            holiInfoList.removeAt(j);
            j--;
        }
    }

//    for(int i = 0; i < playCntList.count(); i++)
//    {
//        qDebug() << i << "playCntList===" << playCntList.at(i).contentFile << playCntList.at(i).isUnlimited;
//    }
    return playCntList;
}


